Working with Location Services and GPS in Android

Course: Android App Development

Topic: Working with Location Services and GPS

Course Link: Android App Development Course

Demo Link: Register for a Free Course Demo

Official Website: JustAcademy

1. Introduction to Location Services in Android

Location services are an important feature of Android application development that enables applications to determine the geographical position of a device. Developers use location information to build navigation applications, fitness trackers, delivery platforms, ride-booking systems, weather applications, and location-based services.

Android devices can estimate their location using GPS satellites, nearby Wi-Fi networks, cellular towers, and other available sensors. Android provides APIs that allow applications to request location information while respecting user permissions and privacy.

For example, a food delivery application can use location services to identify the customer's delivery address, display nearby restaurants, and help delivery partners navigate to the destination.

Learning Objectives

• Understand Android location services and GPS technology.
• Learn the difference between GPS and network-based location.
• Configure location permissions in an Android project.
• Request and retrieve the device's current location.
• Track location updates and manage location listeners.
• Handle permission denial, location settings, and provider errors.
• Implement location features while protecting user privacy and battery life.

2. What Is GPS?

GPS stands for Global Positioning System. It is a satellite-based navigation system that allows compatible devices to calculate their approximate geographical position using signals transmitted by satellites.

A GPS receiver estimates its location by measuring signals from multiple satellites. A clear view of the sky generally improves GPS reception, while buildings, tunnels, and indoor environments may reduce accuracy.

Important Location Coordinates

3. How Android Location Services Work

Android location services combine information from available positioning sources and device capabilities to provide location estimates. Applications generally access this information through Android location APIs instead of communicating directly with GPS satellites.

Common Location Sources

• GPS: Uses satellite signals and can provide accurate outdoor positioning.
• Network location: Uses available network information, such as Wi-Fi and cellular signals, to estimate location.
• Fused location: Combines suitable signals and device information to provide location results through Google Play services.
• Passive location: Allows an application to receive location updates generated for other clients when supported by the selected API.

GPS vs. Network Location

The most suitable source depends on the application's accuracy requirements, environment, power budget, and available device capabilities.

4. Android Location APIs

Android provides different APIs for accessing location information. The correct choice depends on whether the application needs a single location, continuous updates, or platform-level location functionality.

4.1 Fused Location Provider

The Fused Location Provider API from Google Play services is commonly used for efficient location retrieval. It can combine information from multiple sources and allows developers to configure accuracy, update intervals, and location requests.

Common classes include:

• FusedLocationProviderClient: Requests location information and updates.
• LocationRequest: Configures the desired location update behavior in APIs that use this class.
• LocationCallback: Receives location updates from an ongoing request.
• LocationResult: Contains the location results received from the provider.
• Location: Represents a location measurement, including coordinates and accuracy information.

4.2 Android LocationManager

LocationManager is part of the Android platform API. It provides access to supported location providers and can be useful when working directly with platform-level location functionality.

Common methods include:

• getLastKnownLocation(): Retrieves a previously recorded location when one is available and accessible.
• requestLocationUpdates(): Requests recurring location updates.
• removeUpdates(): Stops updates associated with a listener.
• isProviderEnabled(): Checks whether a specified provider is enabled.

For many applications using Google Play services, the Fused Location Provider is a convenient default. Applications must account for the dependencies and provider availability of their target devices.

5. Adding Location Dependencies

To use the Fused Location Provider, add the Google Play services location library to the app-level Gradle file. Check the latest compatible version for your Android project before adding the dependency.

dependencies {
    implementation("com.google.android.gms:play-services-location:<latest-compatible-version>")
}

Replace <latest-compatible-version> with a valid version from the official dependency documentation. Sync the project after updating the Gradle file.

6. Configuring Location Permissions

Android protects location information through runtime permissions. An application must declare the permissions it needs and request the appropriate permission from the user before accessing protected location data.

6.1 Manifest Permissions

For an application that needs approximate or precise foreground location, declare the relevant permissions in AndroidManifest.xml.

<manifest xmlns:android="http://schemas.android.com/apk/res/android">

    <uses-permission
        android:name="android.permission.ACCESS_COARSE_LOCATION" />

    <uses-permission
        android:name="android.permission.ACCESS_FINE_LOCATION" />

    <application
        android:label="Location Demo">

        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

    </application>
</manifest>

Important: Request only the permission level required by your feature. If the user grants approximate location, the application must not assume that precise coordinates are available. Requesting both coarse and fine location is appropriate when precise location is genuinely needed.

6.2 Permission Types

Background location is not necessary for ordinary foreground location features. If background tracking is essential, review Android's version-specific permission requirements and background execution restrictions.

7. Requesting Runtime Location Permission

Declaring a permission in the manifest does not automatically grant it. Modern Android applications must request dangerous permissions at runtime and handle the user's response.

The following Kotlin example uses the Activity Result API to request foreground location permission.

private val locationPermissionLauncher =
    registerForActivityResult(
        ActivityResultContracts.RequestMultiplePermissions()
    ) { permissions ->

        val preciseGranted =
            permissions[Manifest.permission.ACCESS_FINE_LOCATION]
                == true

        val approximateGranted =
            permissions[Manifest.permission.ACCESS_COARSE_LOCATION]
                == true

        if (preciseGranted || approximateGranted) {
            getCurrentLocation()
        } else {
            Toast.makeText(
                this,
                "Location permission is required for this feature.",
                Toast.LENGTH_LONG
            ).show()
        }
    }

private fun requestLocationPermission() {
    locationPermissionLauncher.launch(
        arrayOf(
            Manifest.permission.ACCESS_COARSE_LOCATION,
            Manifest.permission.ACCESS_FINE_LOCATION
        )
    )
}

Required imports include Manifest, Toast, and ActivityResultContracts, along with the appropriate Android framework and Google Play services classes used elsewhere in the activity.

Permission Best Practices

• Explain why location access is needed before displaying the permission request when additional context is helpful.
• Request permissions when the user starts a feature that needs them.
• Handle approximate location as a valid choice when the feature can work with it.
• Provide a useful alternative if the user denies permission.
• Do not repeatedly pressure users who have declined access.

8. Retrieving the Current Location

The Fused Location Provider can retrieve a recent location using getLastLocation(). This method may return no result if the device has no cached location available. A cached result can also be older than the application requires, so its timestamp and accuracy should be checked.

Kotlin Example: Get a Recent Location

private lateinit var fusedLocationClient:
    FusedLocationProviderClient

private fun initializeLocationClient() {
    fusedLocationClient =
        LocationServices.getFusedLocationProviderClient(this)
}

@SuppressLint("MissingPermission")
private fun getCurrentLocation() {
    val fineGranted =
        ContextCompat.checkSelfPermission(
            this,
            Manifest.permission.ACCESS_FINE_LOCATION
        ) == PackageManager.PERMISSION_GRANTED

    val coarseGranted =
        ContextCompat.checkSelfPermission(
            this,
            Manifest.permission.ACCESS_COARSE_LOCATION
        ) == PackageManager.PERMISSION_GRANTED

    if (!fineGranted && !coarseGranted) {
        requestLocationPermission()
        return
    }

    fusedLocationClient.lastLocation
        .addOnSuccessListener { location ->
            if (location != null) {
                val latitude = location.latitude
                val longitude = location.longitude

                val result = "Latitude: $latitude, " +
                    "Longitude: $longitude"

                locationTextView.text = result
            } else {
                locationTextView.text =
                    "No recent location is available."
            }
        }
        .addOnFailureListener {
            locationTextView.text =
                "Unable to retrieve location."
        }
}

Initialize the client in the activity or an appropriate lifecycle-aware component, and connect locationTextView to a valid TextView in the layout. The example assumes that the permission request function from the previous section is available.

The permission checks are performed before accessing the location. The suppression annotation does not grant permission; it only suppresses a static warning after the developer has implemented appropriate runtime checks.

9. Requesting a Fresh Location

A last-known location may not reflect the device's current position. When a feature needs a more recent measurement, use getCurrentLocation() with an appropriate cancellation token and priority.

@SuppressLint("MissingPermission")
private fun requestFreshLocation() {
    val hasFineLocation =
        ContextCompat.checkSelfPermission(
            this,
            Manifest.permission.ACCESS_FINE_LOCATION
        ) == PackageManager.PERMISSION_GRANTED

    val hasCoarseLocation =
        ContextCompat.checkSelfPermission(
            this,
            Manifest.permission.ACCESS_COARSE_LOCATION
        ) == PackageManager.PERMISSION_GRANTED

    if (!hasFineLocation && !hasCoarseLocation) {
        requestLocationPermission()
        return
    }

    val priority =
        if (hasFineLocation) {
            Priority.PRIORITY_HIGH_ACCURACY
        } else {
            Priority.PRIORITY_BALANCED_POWER_ACCURACY
        }

    fusedLocationClient.getCurrentLocation(
        priority,
        CancellationTokenSource().token
    ).addOnSuccessListener { location ->
        if (location != null) {
            locationTextView.text =
                "Lat: ${location.latitude}, " +
                "Lng: ${location.longitude}"
        } else {
            locationTextView.text =
                "Current location is unavailable."
        }
    }.addOnFailureListener {
        locationTextView.text =
            "Could not obtain a location."
    }
}

This example requires imports for Priority and CancellationTokenSource. In a production implementation, retain the cancellation token source and cancel it when the operation is no longer needed. Also handle timeouts and unavailable location settings as appropriate for the application.

10. Understanding Latitude and Longitude

Latitude and longitude are geographic coordinates used to identify a point on Earth. Android's Location object provides coordinate values through its latitude and longitude properties.

• Latitude ranges from -90 to +90 degrees.
• Longitude ranges from -180 to +180 degrees.
• Positive latitude indicates the Northern Hemisphere; negative latitude indicates the Southern Hemisphere.
• Positive longitude indicates locations east of the Prime Meridian; negative longitude indicates locations west of it.

Example coordinate representation:

val latitude = location.latitude
val longitude = location.longitude

val coordinates = "$latitude, $longitude"
locationTextView.text = coordinates

Coordinates can be passed to a mapping SDK or converted into a human-readable address using geocoding services. Coordinates alone do not contain a street address or guarantee that a road or building exists at that point.

11. Continuous Location Tracking

Some applications require repeated location updates rather than a single reading. Examples include fitness applications recording a walking route, navigation applications displaying movement, and delivery applications updating a courier's position.

Continuous tracking should use an appropriate interval, priority, and lifecycle strategy. Frequent high-accuracy requests may increase battery consumption and should be avoided unless they are necessary for the feature.

Example: Receiving Location Updates

private lateinit var locationCallback: LocationCallback

private fun createLocationCallback() {
    locationCallback = object : LocationCallback() {
        override fun onLocationResult(
            result: LocationResult
        ) {
            val location = result.lastLocation ?: return

            locationTextView.text =
                "Lat: ${location.latitude}, " +
                "Lng: ${location.longitude}"
        }
    }
}

Create the callback before requesting updates. When the application has permission and tracking is appropriate, configure a LocationRequest and register the callback with requestLocationUpdates().

Example: Configuring and Starting Updates

@SuppressLint("MissingPermission")
private fun startLocationUpdates() {
    val hasFineLocation =
        ContextCompat.checkSelfPermission(
            this,
            Manifest.permission.ACCESS_FINE_LOCATION
        ) == PackageManager.PERMISSION_GRANTED

    val hasCoarseLocation =
        ContextCompat.checkSelfPermission(
            this,
            Manifest.permission.ACCESS_COARSE_LOCATION
        ) == PackageManager.PERMISSION_GRANTED

    if (!hasFineLocation && !hasCoarseLocation) {
        requestLocationPermission()
        return
    }

    val priority =
        if (hasFineLocation) {
            Priority.PRIORITY_HIGH_ACCURACY
        } else {
            Priority.PRIORITY_BALANCED_POWER_ACCURACY
        }

    val request = LocationRequest.Builder(
        priority,
        10_000L
    )
        .setMinUpdateIntervalMillis(5_000L)
        .build()

    fusedLocationClient.requestLocationUpdates(
        request,
        locationCallback,
        Looper.getMainLooper()
    )
}

The example requests updates approximately every 10 seconds, with a minimum update interval of 5 seconds. These values are preferences rather than guarantees; actual update timing depends on device conditions, permissions, power management, and provider behavior.

Stopping Location Updates

private fun stopLocationUpdates() {
    if (::locationCallback.isInitialized) {
        fusedLocationClient.removeLocationUpdates(
            locationCallback
        )
    }
}

Start and stop tracking in response to the feature's lifecycle and user actions. For example, stop unnecessary foreground updates when the user leaves the tracking screen. If an application genuinely needs ongoing background tracking, implement the required foreground service and permissions for the Android versions being supported.

12. Checking Location Settings

Location permissions and device location settings are different. A user may grant application permission while device settings or the available location providers are still insufficient for the requested operation.

For a fused location request, developers can use SettingsClient with a LocationSettingsRequest to check whether suitable device settings are enabled.

private fun checkLocationSettings(
    request: LocationRequest
) {
    val settingsRequest =
        LocationSettingsRequest.Builder()
            .addLocationRequest(request)
            .build()

    val settingsClient =
        LocationServices.getSettingsClient(this)

    settingsClient.checkLocationSettings(settingsRequest)
        .addOnSuccessListener {
            // Device settings satisfy the request.
            startLocationUpdates()
        }
        .addOnFailureListener { exception ->
            if (exception is ResolvableApiException) {
                // Offer the system resolution flow to the user.
                // Launch it through an Activity Result API
                // or another suitable activity-result mechanism.
            } else {
                locationTextView.text =
                    "Required location settings are unavailable."
            }
        }
}

In a complete implementation, launch the resolution flow when the exception can be resolved and handle the user's response. Do not assume that the user will enable location settings.

13. Displaying Location on Google Maps

Location data becomes more useful when displayed visually. A map can show the current position, nearby places, delivery destinations, and routes. Google Maps SDK for Android is one option for implementing map-based features.

Typical integration steps include:

1. Configure the Google Maps SDK and the required API key.
2. Add a map component to the application layout.
3. Obtain the user's location through a permitted location API.
4. Convert the latitude and longitude into a coordinate object such as LatLng.
5. Move the camera to the selected coordinate and add a marker if appropriate.
6. Handle map lifecycle events and location permissions.

// Example code inside a GoogleMap callback,
// after location permission has been checked
// and a valid location has been obtained.

val position = LatLng(
    location.latitude,
    location.longitude
)

googleMap.addMarker(
    MarkerOptions()
        .position(position)
        .title("Current Location")
)

googleMap.animateCamera(
    CameraUpdateFactory.newLatLngZoom(position, 15f)
)

The code assumes that googleMap and location are valid objects and that the Maps SDK dependencies and imports are configured. A marker displays a coordinate; it does not independently retrieve the device's location.

14. Converting Coordinates into a Human-Readable Address

Reverse geocoding converts geographic coordinates into a possible address or place description. Android provides the Geocoder API for this purpose, although results depend on service availability and geographic coverage.

private fun getAddressFromCoordinates(
    latitude: Double,
    longitude: Double
) {
    if (!Geocoder.isPresent()) {
        addressTextView.text =
            "Geocoding is unavailable on this device."
        return
    }

    val geocoder = Geocoder(this, Locale.getDefault())

    geocoder.getFromLocation(
        latitude,
        longitude,
        1
    ) { addresses ->
        val address = addresses.firstOrNull()

        runOnUiThread {
            addressTextView.text =
                address?.getAddressLine(0)
                    ?: "No address was found."
        }
    }
}

This example uses the asynchronous geocoding overload available on modern Android versions. If supporting older Android versions, use a version-appropriate API and avoid running blocking geocoding operations on the main thread. Always handle empty results and service errors.

15. Managing Location Updates with the Activity Lifecycle

Location requests can continue consuming resources if they are not removed at the appropriate time. Lifecycle-aware management helps prevent unnecessary battery drain, memory leaks, and unwanted tracking.

For screen-bound tracking, a common approach is to register updates while the screen is active and remove them when it stops. More complex applications can use lifecycle-aware components or a repository to coordinate location access across screens.

16. Handling Location Errors and Edge Cases

Location retrieval may fail or return no result for several reasons. Robust applications should handle these situations gracefully rather than assuming that every request will return valid coordinates.

17. Location Accuracy and Battery Optimization

Location accuracy describes how closely a measured position may correspond to the device's actual position. It should not be confused with the number of decimal places displayed in the coordinates.

For example, a location reported with an estimated horizontal accuracy of 50 meters may not be suitable for identifying an exact building entrance, even if its latitude and longitude contain many decimal places.

Optimization Techniques

• Use balanced-power location priority when high precision is unnecessary.
• Request updates only while a location-based feature is active.
• Choose realistic update intervals based on the application's requirements.
• Use cached results when their age and accuracy are acceptable.
• Filter redundant updates when the device has not moved meaningfully.
• Remove callbacks and cancel requests when they are no longer required.
• Avoid storing or transmitting location history without a clear user-facing purpose.

18. Foreground and Background Location Access

Foreground location access is suitable for features used while a user is interacting with the application. Background location is more sensitive because it can reveal movement even when the application is not visible.

Foreground Location Examples

• Showing the user's position on a map.
• Finding nearby restaurants when a user taps a button.
• Choosing a pickup point in a ride-booking application.
• Recording a workout while the user actively starts a tracking session.

Background Location Examples

• Providing an explicitly enabled location-sharing feature.
• Tracking an ongoing route when the application is not visible and the feature requires it.
• Supporting eligible safety or navigation functionality that genuinely requires background access.

Background access requires careful justification and compliance with Android platform policies. Depending on the Android version and application behavior, a feature may need additional permission declarations, separate runtime approval, and a foreground service with the appropriate service type. Request background access only when foreground access cannot meet the feature's needs.

19. Location Privacy and Security

Location information is sensitive user data. Applications should collect, process, and retain it responsibly.

• Explain why location is needed and how it will be used.
• Request the minimum permission required for the feature.
• Prefer on-device processing when remote storage is unnecessary.
• Protect transmitted location data using secure network connections.
• Restrict access to location records and avoid logging precise coordinates unnecessarily.
• Provide a clear way to stop tracking and delete stored location history where applicable.
• Do not continue tracking after the user has disabled the feature unless a separately justified and permitted function requires it.

20. Testing Location Features

Testing should cover different permissions, device settings, location qualities, and lifecycle conditions. Android emulators and physical devices can be used to simulate or generate different locations.

Recommended Test Cases

1. Grant precise location and verify that coordinates are displayed.
2. Grant approximate location and confirm that the application still behaves appropriately.
3. Deny permission and verify that the application provides a useful explanation.
4. Disable location services and test the settings-resolution flow.
5. Test when no cached location is available.
6. Simulate a change in coordinates and verify that the interface updates.
7. Navigate away from the tracking screen and confirm that unnecessary updates stop.
8. Test weak network conditions and poor GPS reception.
9. Check battery usage during a longer tracking session.
10. Verify that sensitive coordinates are not exposed in unnecessary logs.

21. Practical Project: Build a Current Location Finder

Project Objective: Create a simple Android application that requests location permission, obtains the device's location, and displays its latitude and longitude.

Project Requirements

• A button labelled "Get Current Location".
• A text area for displaying latitude and longitude.
• Runtime permission handling for approximate and precise location.
• Loading and error messages for unavailable location data.
• A retry option when the location cannot be retrieved.
• Proper cleanup of any continuous location requests.

Implementation Workflow

1. Create an Android project using Kotlin.
2. Add the Google Play services location dependency.
3. Declare the necessary foreground location permissions.
4. Design the interface with a button and text views.
5. Initialize FusedLocationProviderClient.
6. Request runtime permission after the user selects the location feature.
7. Retrieve a recent or fresh location according to the application's requirements.
8. Display the coordinates and relevant accuracy information.
9. Handle permission denial, missing results, and disabled location settings.
10. Test the application on an emulator and a physical Android device.

Expected Output

Current Location

Latitude: 19.0760
Longitude: 72.8777

Accuracy: Depends on the device and conditions

The coordinates above are illustrative and are not a live reading. Actual output depends on the device's current position and the quality of the location measurement.

22. Common Interview Questions and Answers

Q1. What are location services in Android?

Answer: Location services provide applications with geographical position information using supported sources such as GPS, Wi-Fi, and cellular signals.

Q2. What is GPS?

Answer: GPS is a satellite-based positioning system used to calculate geographical coordinates. It generally works best outdoors with a clear view of the sky.

Q3. What is the Fused Location Provider?

Answer: It is a Google Play services API that combines available location sources to provide location results according to the requested accuracy and power requirements.

Q4. What is the difference between approximate and precise location?

Answer: Approximate location provides a less precise geographical estimate, while precise location allows more accurate positioning when the device, permissions, and environmental conditions support it.

Q5. Why is runtime permission required?

Answer: Location is protected user data. Android requires applications to obtain the appropriate user permission before accessing it.

Q6. What is the difference between getLastLocation() and getCurrentLocation()?

Answer: getLastLocation() returns an available cached location and may return null. getCurrentLocation() requests a current measurement, subject to provider availability, cancellation, and timing constraints.

Q7. What is LocationCallback?

Answer: LocationCallback receives location updates when an application requests recurring updates through the Fused Location Provider.

Q8. How can an application reduce location-related battery consumption?

Answer: Use an appropriate accuracy priority, reduce update frequency, avoid unnecessary background tracking, and remove location callbacks when they are no longer needed.

Q9. What is reverse geocoding?

Answer: Reverse geocoding converts latitude and longitude into a human-readable address or place description when suitable data is available.

Q10. Why can a location request return null?

Answer: There may be no cached measurement, location services may be unavailable, or the provider may not have obtained a suitable result yet.

Q11. How should an application handle denied location permission?

Answer: It should explain which feature is affected, offer a reasonable alternative, and request permission again only when appropriate.

Q12. What should developers consider before implementing background location tracking?

Answer: They should establish a genuine feature requirement, explain tracking to users, request the required permissions, follow foreground-service rules where applicable, and minimize collection and retention of location data.

23. Practice Exercises

1. Create an application that displays latitude and longitude after a button click.
2. Add permission handling for approximate and precise location.
3. Display the estimated accuracy of each location measurement.
4. Add a loading indicator while waiting for a fresh location.
5. Implement a retry button for unavailable location data.
6. Display the current position on a Google Map.
7. Convert coordinates into a readable address using reverse geocoding.
8. Create a foreground tracking screen that updates coordinates and stops when tracking ends.
9. Test the application with location permission denied and location services disabled.
10. Review the implementation for battery usage, privacy, and lifecycle cleanup.

24. Quick Revision Checklist

• Understand GPS, network location, and fused location.
• Know the purpose of latitude, longitude, accuracy, and timestamps.
• Declare and request the appropriate location permissions.
• Check permission status before accessing location information.
• Choose between cached location, fresh location, and continuous updates.
• Handle missing results, permission denial, and unavailable settings.
• Remove location callbacks when tracking is no longer needed.
• Optimize accuracy and update intervals for battery efficiency.
• Protect location information and explain its use to the user.
• Test location features across different device and permission conditions.

25. Conclusion

Working with location services and GPS is an essential Android development skill for building navigation, delivery, fitness, mapping, and location-aware applications. Android's location APIs make it possible to obtain current coordinates, monitor movement, and integrate location information with maps and other services.

A reliable implementation requires more than retrieving latitude and longitude. Developers must also manage runtime permissions, account for approximate location, handle unavailable results, respect application lifecycle events, optimize battery usage, and protect user privacy.

By completing the practical exercises in these notes, learners can build a foundation for implementing secure, efficient, and user-friendly location features in Android applications.

Explore Android App Development Training

Learn more about Android application development and related practical skills through JustAcademy.

Explore the Android App Development Course

Register for a Course Demo

Visit the JustAcademy Website